// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.amazon.order.list.detail;

import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class AmazonOrderListDetailSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "AmazonOrderListDetail".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 亚马逊订单号(模糊搜索)
   */
  private String amazonOrderId;

  /**
   * 亚马逊订单号 比较(eq)
   */
  private String amazonOrderIdEq;
  /**
   * 亚马逊订单号 比较(neq)
   */
  private String amazonOrderIdNeq;
  /**
   * 亚马逊订单号 比较(gt)
   */
  private String amazonOrderIdGt;
  /**
   * 亚马逊订单号 比较(gte)
   */
  private String amazonOrderIdGte;
  /**
   * 亚马逊订单号 比较(lt)
   */
  private String amazonOrderIdLt;
  /**
   * 亚马逊订单号 比较(lte)
   */
  private String amazonOrderIdLte;
  /**
   * 亚马逊订单号 比较(contains)
   */
  private String amazonOrderIdContains;
  /**
   * 亚马逊订单号 比较(notcontains)
   */
  private String amazonOrderIdNotcontains;
  /**
   * 亚马逊订单号 比较(startswith)
   */
  private String amazonOrderIdStartswith;
  /**
   * 亚马逊订单号 比较(endswith)
   */
  private String amazonOrderIdEndswith;
  /**
   * 亚马逊订单号 比较(isnull)
   */
  private Boolean amazonOrderIdIsnull;
  /**
   * 亚马逊订单号 比较(isnotnull)
   */
  private Boolean amazonOrderIdIsnotnull;

  /**
   * 亚马逊订单号(精确搜索)
   */
  private List<String> amazonOrderIdInList;

  /**
   * 买家姓名(模糊搜索)
   */
  private String buyerName;

  /**
   * 买家姓名 比较(eq)
   */
  private String buyerNameEq;
  /**
   * 买家姓名 比较(neq)
   */
  private String buyerNameNeq;
  /**
   * 买家姓名 比较(gt)
   */
  private String buyerNameGt;
  /**
   * 买家姓名 比较(gte)
   */
  private String buyerNameGte;
  /**
   * 买家姓名 比较(lt)
   */
  private String buyerNameLt;
  /**
   * 买家姓名 比较(lte)
   */
  private String buyerNameLte;
  /**
   * 买家姓名 比较(contains)
   */
  private String buyerNameContains;
  /**
   * 买家姓名 比较(notcontains)
   */
  private String buyerNameNotcontains;
  /**
   * 买家姓名 比较(startswith)
   */
  private String buyerNameStartswith;
  /**
   * 买家姓名 比较(endswith)
   */
  private String buyerNameEndswith;
  /**
   * 买家姓名 比较(isnull)
   */
  private Boolean buyerNameIsnull;
  /**
   * 买家姓名 比较(isnotnull)
   */
  private Boolean buyerNameIsnotnull;

  /**
   * 买家姓名(精确搜索)
   */
  private List<String> buyerNameInList;

  /**
   * 买家邮件(模糊搜索)
   */
  private String buyerEmail;

  /**
   * 买家邮件 比较(eq)
   */
  private String buyerEmailEq;
  /**
   * 买家邮件 比较(neq)
   */
  private String buyerEmailNeq;
  /**
   * 买家邮件 比较(gt)
   */
  private String buyerEmailGt;
  /**
   * 买家邮件 比较(gte)
   */
  private String buyerEmailGte;
  /**
   * 买家邮件 比较(lt)
   */
  private String buyerEmailLt;
  /**
   * 买家邮件 比较(lte)
   */
  private String buyerEmailLte;
  /**
   * 买家邮件 比较(contains)
   */
  private String buyerEmailContains;
  /**
   * 买家邮件 比较(notcontains)
   */
  private String buyerEmailNotcontains;
  /**
   * 买家邮件 比较(startswith)
   */
  private String buyerEmailStartswith;
  /**
   * 买家邮件 比较(endswith)
   */
  private String buyerEmailEndswith;
  /**
   * 买家邮件 比较(isnull)
   */
  private Boolean buyerEmailIsnull;
  /**
   * 买家邮件 比较(isnotnull)
   */
  private Boolean buyerEmailIsnotnull;

  /**
   * 买家邮件(精确搜索)
   */
  private List<String> buyerEmailInList;

  /**
   * 用户收货地址(模糊搜索)
   */
  private String address;

  /**
   * 用户收货地址 比较(eq)
   */
  private String addressEq;
  /**
   * 用户收货地址 比较(neq)
   */
  private String addressNeq;
  /**
   * 用户收货地址 比较(gt)
   */
  private String addressGt;
  /**
   * 用户收货地址 比较(gte)
   */
  private String addressGte;
  /**
   * 用户收货地址 比较(lt)
   */
  private String addressLt;
  /**
   * 用户收货地址 比较(lte)
   */
  private String addressLte;
  /**
   * 用户收货地址 比较(contains)
   */
  private String addressContains;
  /**
   * 用户收货地址 比较(notcontains)
   */
  private String addressNotcontains;
  /**
   * 用户收货地址 比较(startswith)
   */
  private String addressStartswith;
  /**
   * 用户收货地址 比较(endswith)
   */
  private String addressEndswith;
  /**
   * 用户收货地址 比较(isnull)
   */
  private Boolean addressIsnull;
  /**
   * 用户收货地址 比较(isnotnull)
   */
  private Boolean addressIsnotnull;

  /**
   * 用户收货地址(精确搜索)
   */
  private List<String> addressInList;

  /**
   * 省州简码(模糊搜索)
   */
  private String stateOrRegion;

  /**
   * 省州简码 比较(eq)
   */
  private String stateOrRegionEq;
  /**
   * 省州简码 比较(neq)
   */
  private String stateOrRegionNeq;
  /**
   * 省州简码 比较(gt)
   */
  private String stateOrRegionGt;
  /**
   * 省州简码 比较(gte)
   */
  private String stateOrRegionGte;
  /**
   * 省州简码 比较(lt)
   */
  private String stateOrRegionLt;
  /**
   * 省州简码 比较(lte)
   */
  private String stateOrRegionLte;
  /**
   * 省州简码 比较(contains)
   */
  private String stateOrRegionContains;
  /**
   * 省州简码 比较(notcontains)
   */
  private String stateOrRegionNotcontains;
  /**
   * 省州简码 比较(startswith)
   */
  private String stateOrRegionStartswith;
  /**
   * 省州简码 比较(endswith)
   */
  private String stateOrRegionEndswith;
  /**
   * 省州简码 比较(isnull)
   */
  private Boolean stateOrRegionIsnull;
  /**
   * 省州简码 比较(isnotnull)
   */
  private Boolean stateOrRegionIsnotnull;

  /**
   * 省州简码(精确搜索)
   */
  private List<String> stateOrRegionInList;

  /**
   * 发货渠道(模糊搜索)
   */
  private String fulfillmentChannel;

  /**
   * 发货渠道 比较(eq)
   */
  private String fulfillmentChannelEq;
  /**
   * 发货渠道 比较(neq)
   */
  private String fulfillmentChannelNeq;
  /**
   * 发货渠道 比较(gt)
   */
  private String fulfillmentChannelGt;
  /**
   * 发货渠道 比较(gte)
   */
  private String fulfillmentChannelGte;
  /**
   * 发货渠道 比较(lt)
   */
  private String fulfillmentChannelLt;
  /**
   * 发货渠道 比较(lte)
   */
  private String fulfillmentChannelLte;
  /**
   * 发货渠道 比较(contains)
   */
  private String fulfillmentChannelContains;
  /**
   * 发货渠道 比较(notcontains)
   */
  private String fulfillmentChannelNotcontains;
  /**
   * 发货渠道 比较(startswith)
   */
  private String fulfillmentChannelStartswith;
  /**
   * 发货渠道 比较(endswith)
   */
  private String fulfillmentChannelEndswith;
  /**
   * 发货渠道 比较(isnull)
   */
  private Boolean fulfillmentChannelIsnull;
  /**
   * 发货渠道 比较(isnotnull)
   */
  private Boolean fulfillmentChannelIsnotnull;

  /**
   * 发货渠道(精确搜索)
   */
  private List<String> fulfillmentChannelInList;

  /**
   * 店铺编码(模糊搜索)
   */
  private String shopCode;

  /**
   * 店铺编码 比较(eq)
   */
  private String shopCodeEq;
  /**
   * 店铺编码 比较(neq)
   */
  private String shopCodeNeq;
  /**
   * 店铺编码 比较(gt)
   */
  private String shopCodeGt;
  /**
   * 店铺编码 比较(gte)
   */
  private String shopCodeGte;
  /**
   * 店铺编码 比较(lt)
   */
  private String shopCodeLt;
  /**
   * 店铺编码 比较(lte)
   */
  private String shopCodeLte;
  /**
   * 店铺编码 比较(contains)
   */
  private String shopCodeContains;
  /**
   * 店铺编码 比较(notcontains)
   */
  private String shopCodeNotcontains;
  /**
   * 店铺编码 比较(startswith)
   */
  private String shopCodeStartswith;
  /**
   * 店铺编码 比较(endswith)
   */
  private String shopCodeEndswith;
  /**
   * 店铺编码 比较(isnull)
   */
  private Boolean shopCodeIsnull;
  /**
   * 店铺编码 比较(isnotnull)
   */
  private Boolean shopCodeIsnotnull;

  /**
   * 店铺编码(精确搜索)
   */
  private List<String> shopCodeInList;

  /**
   * 店铺id
   */
  private Long shopId;

  /**
   * 最小店铺id
   */
  private Long shopIdMin;

  /**
   * 最大店铺id
   */
  private Long shopIdMax;

  /**
   * 店铺id 比较(eq)
   */
  private Long shopIdEq;
  /**
   * 店铺id 比较(neq)
   */
  private Long shopIdNeq;
  /**
   * 店铺id 比较(gt)
   */
  private Long shopIdGt;
  /**
   * 店铺id 比较(gte)
   */
  private Long shopIdGte;
  /**
   * 店铺id 比较(lt)
   */
  private Long shopIdLt;
  /**
   * 店铺id 比较(lte)
   */
  private Long shopIdLte;
  /**
   * 店铺id 比较(contains)
   */
  private Long shopIdContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private Long shopIdNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private Long shopIdStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private Long shopIdEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;

  /**
   * 国家(模糊搜索)
   */
  private String country;

  /**
   * 国家 比较(eq)
   */
  private String countryEq;
  /**
   * 国家 比较(neq)
   */
  private String countryNeq;
  /**
   * 国家 比较(gt)
   */
  private String countryGt;
  /**
   * 国家 比较(gte)
   */
  private String countryGte;
  /**
   * 国家 比较(lt)
   */
  private String countryLt;
  /**
   * 国家 比较(lte)
   */
  private String countryLte;
  /**
   * 国家 比较(contains)
   */
  private String countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> countryInList;

  /**
   * 城市(模糊搜索)
   */
  private String city;

  /**
   * 城市 比较(eq)
   */
  private String cityEq;
  /**
   * 城市 比较(neq)
   */
  private String cityNeq;
  /**
   * 城市 比较(gt)
   */
  private String cityGt;
  /**
   * 城市 比较(gte)
   */
  private String cityGte;
  /**
   * 城市 比较(lt)
   */
  private String cityLt;
  /**
   * 城市 比较(lte)
   */
  private String cityLte;
  /**
   * 城市 比较(contains)
   */
  private String cityContains;
  /**
   * 城市 比较(notcontains)
   */
  private String cityNotcontains;
  /**
   * 城市 比较(startswith)
   */
  private String cityStartswith;
  /**
   * 城市 比较(endswith)
   */
  private String cityEndswith;
  /**
   * 城市 比较(isnull)
   */
  private Boolean cityIsnull;
  /**
   * 城市 比较(isnotnull)
   */
  private Boolean cityIsnotnull;

  /**
   * 城市(精确搜索)
   */
  private List<String> cityInList;

  /**
   * 地区(模糊搜索)
   */
  private String district;

  /**
   * 地区 比较(eq)
   */
  private String districtEq;
  /**
   * 地区 比较(neq)
   */
  private String districtNeq;
  /**
   * 地区 比较(gt)
   */
  private String districtGt;
  /**
   * 地区 比较(gte)
   */
  private String districtGte;
  /**
   * 地区 比较(lt)
   */
  private String districtLt;
  /**
   * 地区 比较(lte)
   */
  private String districtLte;
  /**
   * 地区 比较(contains)
   */
  private String districtContains;
  /**
   * 地区 比较(notcontains)
   */
  private String districtNotcontains;
  /**
   * 地区 比较(startswith)
   */
  private String districtStartswith;
  /**
   * 地区 比较(endswith)
   */
  private String districtEndswith;
  /**
   * 地区 比较(isnull)
   */
  private Boolean districtIsnull;
  /**
   * 地区 比较(isnotnull)
   */
  private Boolean districtIsnotnull;

  /**
   * 地区(精确搜索)
   */
  private List<String> districtInList;

  /**
   * 状态(模糊搜索)
   */
  private String orderStatus;

  /**
   * 状态 比较(eq)
   */
  private String orderStatusEq;
  /**
   * 状态 比较(neq)
   */
  private String orderStatusNeq;
  /**
   * 状态 比较(gt)
   */
  private String orderStatusGt;
  /**
   * 状态 比较(gte)
   */
  private String orderStatusGte;
  /**
   * 状态 比较(lt)
   */
  private String orderStatusLt;
  /**
   * 状态 比较(lte)
   */
  private String orderStatusLte;
  /**
   * 状态 比较(contains)
   */
  private String orderStatusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String orderStatusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String orderStatusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String orderStatusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean orderStatusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean orderStatusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> orderStatusInList;

  /**
   * 是否评测订单
   */
  private Long isAssessed;

  /**
   * 最小是否评测订单
   */
  private Long isAssessedMin;

  /**
   * 最大是否评测订单
   */
  private Long isAssessedMax;

  /**
   * 是否评测订单 比较(eq)
   */
  private Long isAssessedEq;
  /**
   * 是否评测订单 比较(neq)
   */
  private Long isAssessedNeq;
  /**
   * 是否评测订单 比较(gt)
   */
  private Long isAssessedGt;
  /**
   * 是否评测订单 比较(gte)
   */
  private Long isAssessedGte;
  /**
   * 是否评测订单 比较(lt)
   */
  private Long isAssessedLt;
  /**
   * 是否评测订单 比较(lte)
   */
  private Long isAssessedLte;
  /**
   * 是否评测订单 比较(contains)
   */
  private Long isAssessedContains;
  /**
   * 是否评测订单 比较(notcontains)
   */
  private Long isAssessedNotcontains;
  /**
   * 是否评测订单 比较(startswith)
   */
  private Long isAssessedStartswith;
  /**
   * 是否评测订单 比较(endswith)
   */
  private Long isAssessedEndswith;
  /**
   * 是否评测订单 比较(isnull)
   */
  private Boolean isAssessedIsnull;
  /**
   * 是否评测订单 比较(isnotnull)
   */
  private Boolean isAssessedIsnotnull;

  /**
   * 订单总金额(模糊搜索)
   */
  private String orderTotalAmount;

  /**
   * 订单总金额 比较(eq)
   */
  private String orderTotalAmountEq;
  /**
   * 订单总金额 比较(neq)
   */
  private String orderTotalAmountNeq;
  /**
   * 订单总金额 比较(gt)
   */
  private String orderTotalAmountGt;
  /**
   * 订单总金额 比较(gte)
   */
  private String orderTotalAmountGte;
  /**
   * 订单总金额 比较(lt)
   */
  private String orderTotalAmountLt;
  /**
   * 订单总金额 比较(lte)
   */
  private String orderTotalAmountLte;
  /**
   * 订单总金额 比较(contains)
   */
  private String orderTotalAmountContains;
  /**
   * 订单总金额 比较(notcontains)
   */
  private String orderTotalAmountNotcontains;
  /**
   * 订单总金额 比较(startswith)
   */
  private String orderTotalAmountStartswith;
  /**
   * 订单总金额 比较(endswith)
   */
  private String orderTotalAmountEndswith;
  /**
   * 订单总金额 比较(isnull)
   */
  private Boolean orderTotalAmountIsnull;
  /**
   * 订单总金额 比较(isnotnull)
   */
  private Boolean orderTotalAmountIsnotnull;

  /**
   * 订单总金额(精确搜索)
   */
  private List<String> orderTotalAmountInList;

  /**
   * 订单金额币种(模糊搜索)
   */
  private String currency;

  /**
   * 订单金额币种 比较(eq)
   */
  private String currencyEq;
  /**
   * 订单金额币种 比较(neq)
   */
  private String currencyNeq;
  /**
   * 订单金额币种 比较(gt)
   */
  private String currencyGt;
  /**
   * 订单金额币种 比较(gte)
   */
  private String currencyGte;
  /**
   * 订单金额币种 比较(lt)
   */
  private String currencyLt;
  /**
   * 订单金额币种 比较(lte)
   */
  private String currencyLte;
  /**
   * 订单金额币种 比较(contains)
   */
  private String currencyContains;
  /**
   * 订单金额币种 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 订单金额币种 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 订单金额币种 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 订单金额币种 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 订单金额币种 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 订单金额币种(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 订单金额币种符号(模糊搜索)
   */
  private String icon;

  /**
   * 订单金额币种符号 比较(eq)
   */
  private String iconEq;
  /**
   * 订单金额币种符号 比较(neq)
   */
  private String iconNeq;
  /**
   * 订单金额币种符号 比较(gt)
   */
  private String iconGt;
  /**
   * 订单金额币种符号 比较(gte)
   */
  private String iconGte;
  /**
   * 订单金额币种符号 比较(lt)
   */
  private String iconLt;
  /**
   * 订单金额币种符号 比较(lte)
   */
  private String iconLte;
  /**
   * 订单金额币种符号 比较(contains)
   */
  private String iconContains;
  /**
   * 订单金额币种符号 比较(notcontains)
   */
  private String iconNotcontains;
  /**
   * 订单金额币种符号 比较(startswith)
   */
  private String iconStartswith;
  /**
   * 订单金额币种符号 比较(endswith)
   */
  private String iconEndswith;
  /**
   * 订单金额币种符号 比较(isnull)
   */
  private Boolean iconIsnull;
  /**
   * 订单金额币种符号 比较(isnotnull)
   */
  private Boolean iconIsnotnull;

  /**
   * 订单金额币种符号(精确搜索)
   */
  private List<String> iconInList;

  /**
   * 邮编(模糊搜索)
   */
  private String postalCode;

  /**
   * 邮编 比较(eq)
   */
  private String postalCodeEq;
  /**
   * 邮编 比较(neq)
   */
  private String postalCodeNeq;
  /**
   * 邮编 比较(gt)
   */
  private String postalCodeGt;
  /**
   * 邮编 比较(gte)
   */
  private String postalCodeGte;
  /**
   * 邮编 比较(lt)
   */
  private String postalCodeLt;
  /**
   * 邮编 比较(lte)
   */
  private String postalCodeLte;
  /**
   * 邮编 比较(contains)
   */
  private String postalCodeContains;
  /**
   * 邮编 比较(notcontains)
   */
  private String postalCodeNotcontains;
  /**
   * 邮编 比较(startswith)
   */
  private String postalCodeStartswith;
  /**
   * 邮编 比较(endswith)
   */
  private String postalCodeEndswith;
  /**
   * 邮编 比较(isnull)
   */
  private Boolean postalCodeIsnull;
  /**
   * 邮编 比较(isnotnull)
   */
  private Boolean postalCodeIsnotnull;

  /**
   * 邮编(精确搜索)
   */
  private List<String> postalCodeInList;

  /**
   * 是否多渠道订单(模糊搜索)
   */
  private String isMcfOrder;

  /**
   * 是否多渠道订单 比较(eq)
   */
  private String isMcfOrderEq;
  /**
   * 是否多渠道订单 比较(neq)
   */
  private String isMcfOrderNeq;
  /**
   * 是否多渠道订单 比较(gt)
   */
  private String isMcfOrderGt;
  /**
   * 是否多渠道订单 比较(gte)
   */
  private String isMcfOrderGte;
  /**
   * 是否多渠道订单 比较(lt)
   */
  private String isMcfOrderLt;
  /**
   * 是否多渠道订单 比较(lte)
   */
  private String isMcfOrderLte;
  /**
   * 是否多渠道订单 比较(contains)
   */
  private String isMcfOrderContains;
  /**
   * 是否多渠道订单 比较(notcontains)
   */
  private String isMcfOrderNotcontains;
  /**
   * 是否多渠道订单 比较(startswith)
   */
  private String isMcfOrderStartswith;
  /**
   * 是否多渠道订单 比较(endswith)
   */
  private String isMcfOrderEndswith;
  /**
   * 是否多渠道订单 比较(isnull)
   */
  private Boolean isMcfOrderIsnull;
  /**
   * 是否多渠道订单 比较(isnotnull)
   */
  private Boolean isMcfOrderIsnotnull;

  /**
   * 是否多渠道订单(精确搜索)
   */
  private List<String> isMcfOrderInList;

  /**
   * 是否退货订单(模糊搜索)
   */
  private String isReturnOrder;

  /**
   * 是否退货订单 比较(eq)
   */
  private String isReturnOrderEq;
  /**
   * 是否退货订单 比较(neq)
   */
  private String isReturnOrderNeq;
  /**
   * 是否退货订单 比较(gt)
   */
  private String isReturnOrderGt;
  /**
   * 是否退货订单 比较(gte)
   */
  private String isReturnOrderGte;
  /**
   * 是否退货订单 比较(lt)
   */
  private String isReturnOrderLt;
  /**
   * 是否退货订单 比较(lte)
   */
  private String isReturnOrderLte;
  /**
   * 是否退货订单 比较(contains)
   */
  private String isReturnOrderContains;
  /**
   * 是否退货订单 比较(notcontains)
   */
  private String isReturnOrderNotcontains;
  /**
   * 是否退货订单 比较(startswith)
   */
  private String isReturnOrderStartswith;
  /**
   * 是否退货订单 比较(endswith)
   */
  private String isReturnOrderEndswith;
  /**
   * 是否退货订单 比较(isnull)
   */
  private Boolean isReturnOrderIsnull;
  /**
   * 是否退货订单 比较(isnotnull)
   */
  private Boolean isReturnOrderIsnotnull;

  /**
   * 是否退货订单(精确搜索)
   */
  private List<String> isReturnOrderInList;

  /**
   * 是否已换货(模糊搜索)
   */
  private String isReplacedOrder;

  /**
   * 是否已换货 比较(eq)
   */
  private String isReplacedOrderEq;
  /**
   * 是否已换货 比较(neq)
   */
  private String isReplacedOrderNeq;
  /**
   * 是否已换货 比较(gt)
   */
  private String isReplacedOrderGt;
  /**
   * 是否已换货 比较(gte)
   */
  private String isReplacedOrderGte;
  /**
   * 是否已换货 比较(lt)
   */
  private String isReplacedOrderLt;
  /**
   * 是否已换货 比较(lte)
   */
  private String isReplacedOrderLte;
  /**
   * 是否已换货 比较(contains)
   */
  private String isReplacedOrderContains;
  /**
   * 是否已换货 比较(notcontains)
   */
  private String isReplacedOrderNotcontains;
  /**
   * 是否已换货 比较(startswith)
   */
  private String isReplacedOrderStartswith;
  /**
   * 是否已换货 比较(endswith)
   */
  private String isReplacedOrderEndswith;
  /**
   * 是否已换货 比较(isnull)
   */
  private Boolean isReplacedOrderIsnull;
  /**
   * 是否已换货 比较(isnotnull)
   */
  private Boolean isReplacedOrderIsnotnull;

  /**
   * 是否已换货(精确搜索)
   */
  private List<String> isReplacedOrderInList;

  /**
   * 是否换货订单(模糊搜索)
   */
  private String isReplacementOrder;

  /**
   * 是否换货订单 比较(eq)
   */
  private String isReplacementOrderEq;
  /**
   * 是否换货订单 比较(neq)
   */
  private String isReplacementOrderNeq;
  /**
   * 是否换货订单 比较(gt)
   */
  private String isReplacementOrderGt;
  /**
   * 是否换货订单 比较(gte)
   */
  private String isReplacementOrderGte;
  /**
   * 是否换货订单 比较(lt)
   */
  private String isReplacementOrderLt;
  /**
   * 是否换货订单 比较(lte)
   */
  private String isReplacementOrderLte;
  /**
   * 是否换货订单 比较(contains)
   */
  private String isReplacementOrderContains;
  /**
   * 是否换货订单 比较(notcontains)
   */
  private String isReplacementOrderNotcontains;
  /**
   * 是否换货订单 比较(startswith)
   */
  private String isReplacementOrderStartswith;
  /**
   * 是否换货订单 比较(endswith)
   */
  private String isReplacementOrderEndswith;
  /**
   * 是否换货订单 比较(isnull)
   */
  private Boolean isReplacementOrderIsnull;
  /**
   * 是否换货订单 比较(isnotnull)
   */
  private Boolean isReplacementOrderIsnotnull;

  /**
   * 是否换货订单(精确搜索)
   */
  private List<String> isReplacementOrderInList;

  /**
   * 国家代码(模糊搜索)
   */
  private String countryCode;

  /**
   * 国家代码 比较(eq)
   */
  private String countryCodeEq;
  /**
   * 国家代码 比较(neq)
   */
  private String countryCodeNeq;
  /**
   * 国家代码 比较(gt)
   */
  private String countryCodeGt;
  /**
   * 国家代码 比较(gte)
   */
  private String countryCodeGte;
  /**
   * 国家代码 比较(lt)
   */
  private String countryCodeLt;
  /**
   * 国家代码 比较(lte)
   */
  private String countryCodeLte;
  /**
   * 国家代码 比较(contains)
   */
  private String countryCodeContains;
  /**
   * 国家代码 比较(notcontains)
   */
  private String countryCodeNotcontains;
  /**
   * 国家代码 比较(startswith)
   */
  private String countryCodeStartswith;
  /**
   * 国家代码 比较(endswith)
   */
  private String countryCodeEndswith;
  /**
   * 国家代码 比较(isnull)
   */
  private Boolean countryCodeIsnull;
  /**
   * 国家代码 比较(isnotnull)
   */
  private Boolean countryCodeIsnotnull;

  /**
   * 国家代码(精确搜索)
   */
  private List<String> countryCodeInList;

  /**
   * 订购时间(模糊搜索)
   */
  private String purchaseDateLocal;

  /**
   * 订购时间 比较(eq)
   */
  private String purchaseDateLocalEq;
  /**
   * 订购时间 比较(neq)
   */
  private String purchaseDateLocalNeq;
  /**
   * 订购时间 比较(gt)
   */
  private String purchaseDateLocalGt;
  /**
   * 订购时间 比较(gte)
   */
  private String purchaseDateLocalGte;
  /**
   * 订购时间 比较(lt)
   */
  private String purchaseDateLocalLt;
  /**
   * 订购时间 比较(lte)
   */
  private String purchaseDateLocalLte;
  /**
   * 订购时间 比较(contains)
   */
  private String purchaseDateLocalContains;
  /**
   * 订购时间 比较(notcontains)
   */
  private String purchaseDateLocalNotcontains;
  /**
   * 订购时间 比较(startswith)
   */
  private String purchaseDateLocalStartswith;
  /**
   * 订购时间 比较(endswith)
   */
  private String purchaseDateLocalEndswith;
  /**
   * 订购时间 比较(isnull)
   */
  private Boolean purchaseDateLocalIsnull;
  /**
   * 订购时间 比较(isnotnull)
   */
  private Boolean purchaseDateLocalIsnotnull;

  /**
   * 订购时间(精确搜索)
   */
  private List<String> purchaseDateLocalInList;

  /**
   * 下单时间（UTC）(模糊搜索)
   */
  private String purchaseDateLocalUtc;

  /**
   * 下单时间（UTC） 比较(eq)
   */
  private String purchaseDateLocalUtcEq;
  /**
   * 下单时间（UTC） 比较(neq)
   */
  private String purchaseDateLocalUtcNeq;
  /**
   * 下单时间（UTC） 比较(gt)
   */
  private String purchaseDateLocalUtcGt;
  /**
   * 下单时间（UTC） 比较(gte)
   */
  private String purchaseDateLocalUtcGte;
  /**
   * 下单时间（UTC） 比较(lt)
   */
  private String purchaseDateLocalUtcLt;
  /**
   * 下单时间（UTC） 比较(lte)
   */
  private String purchaseDateLocalUtcLte;
  /**
   * 下单时间（UTC） 比较(contains)
   */
  private String purchaseDateLocalUtcContains;
  /**
   * 下单时间（UTC） 比较(notcontains)
   */
  private String purchaseDateLocalUtcNotcontains;
  /**
   * 下单时间（UTC） 比较(startswith)
   */
  private String purchaseDateLocalUtcStartswith;
  /**
   * 下单时间（UTC） 比较(endswith)
   */
  private String purchaseDateLocalUtcEndswith;
  /**
   * 下单时间（UTC） 比较(isnull)
   */
  private Boolean purchaseDateLocalUtcIsnull;
  /**
   * 下单时间（UTC） 比较(isnotnull)
   */
  private Boolean purchaseDateLocalUtcIsnotnull;

  /**
   * 下单时间（UTC）(精确搜索)
   */
  private List<String> purchaseDateLocalUtcInList;

  /**
   * 订单更新站点时间(模糊搜索)
   */
  private String lastUpdateDate;

  /**
   * 订单更新站点时间 比较(eq)
   */
  private String lastUpdateDateEq;
  /**
   * 订单更新站点时间 比较(neq)
   */
  private String lastUpdateDateNeq;
  /**
   * 订单更新站点时间 比较(gt)
   */
  private String lastUpdateDateGt;
  /**
   * 订单更新站点时间 比较(gte)
   */
  private String lastUpdateDateGte;
  /**
   * 订单更新站点时间 比较(lt)
   */
  private String lastUpdateDateLt;
  /**
   * 订单更新站点时间 比较(lte)
   */
  private String lastUpdateDateLte;
  /**
   * 订单更新站点时间 比较(contains)
   */
  private String lastUpdateDateContains;
  /**
   * 订单更新站点时间 比较(notcontains)
   */
  private String lastUpdateDateNotcontains;
  /**
   * 订单更新站点时间 比较(startswith)
   */
  private String lastUpdateDateStartswith;
  /**
   * 订单更新站点时间 比较(endswith)
   */
  private String lastUpdateDateEndswith;
  /**
   * 订单更新站点时间 比较(isnull)
   */
  private Boolean lastUpdateDateIsnull;
  /**
   * 订单更新站点时间 比较(isnotnull)
   */
  private Boolean lastUpdateDateIsnotnull;

  /**
   * 订单更新站点时间(精确搜索)
   */
  private List<String> lastUpdateDateInList;

  /**
   * 订单更新站点时间（UTC）(模糊搜索)
   */
  private String lastUpdateDateUtc;

  /**
   * 订单更新站点时间（UTC） 比较(eq)
   */
  private String lastUpdateDateUtcEq;
  /**
   * 订单更新站点时间（UTC） 比较(neq)
   */
  private String lastUpdateDateUtcNeq;
  /**
   * 订单更新站点时间（UTC） 比较(gt)
   */
  private String lastUpdateDateUtcGt;
  /**
   * 订单更新站点时间（UTC） 比较(gte)
   */
  private String lastUpdateDateUtcGte;
  /**
   * 订单更新站点时间（UTC） 比较(lt)
   */
  private String lastUpdateDateUtcLt;
  /**
   * 订单更新站点时间（UTC） 比较(lte)
   */
  private String lastUpdateDateUtcLte;
  /**
   * 订单更新站点时间（UTC） 比较(contains)
   */
  private String lastUpdateDateUtcContains;
  /**
   * 订单更新站点时间（UTC） 比较(notcontains)
   */
  private String lastUpdateDateUtcNotcontains;
  /**
   * 订单更新站点时间（UTC） 比较(startswith)
   */
  private String lastUpdateDateUtcStartswith;
  /**
   * 订单更新站点时间（UTC） 比较(endswith)
   */
  private String lastUpdateDateUtcEndswith;
  /**
   * 订单更新站点时间（UTC） 比较(isnull)
   */
  private Boolean lastUpdateDateUtcIsnull;
  /**
   * 订单更新站点时间（UTC） 比较(isnotnull)
   */
  private Boolean lastUpdateDateUtcIsnotnull;

  /**
   * 订单更新站点时间（UTC）(精确搜索)
   */
  private List<String> lastUpdateDateUtcInList;

  /**
   * 发货时限(模糊搜索)
   */
  private String earliestShipDate;

  /**
   * 发货时限 比较(eq)
   */
  private String earliestShipDateEq;
  /**
   * 发货时限 比较(neq)
   */
  private String earliestShipDateNeq;
  /**
   * 发货时限 比较(gt)
   */
  private String earliestShipDateGt;
  /**
   * 发货时限 比较(gte)
   */
  private String earliestShipDateGte;
  /**
   * 发货时限 比较(lt)
   */
  private String earliestShipDateLt;
  /**
   * 发货时限 比较(lte)
   */
  private String earliestShipDateLte;
  /**
   * 发货时限 比较(contains)
   */
  private String earliestShipDateContains;
  /**
   * 发货时限 比较(notcontains)
   */
  private String earliestShipDateNotcontains;
  /**
   * 发货时限 比较(startswith)
   */
  private String earliestShipDateStartswith;
  /**
   * 发货时限 比较(endswith)
   */
  private String earliestShipDateEndswith;
  /**
   * 发货时限 比较(isnull)
   */
  private Boolean earliestShipDateIsnull;
  /**
   * 发货时限 比较(isnotnull)
   */
  private Boolean earliestShipDateIsnotnull;

  /**
   * 发货时限(精确搜索)
   */
  private List<String> earliestShipDateInList;

  /**
   * 发货时限（UTC）(模糊搜索)
   */
  private String earliestShipDateUtc;

  /**
   * 发货时限（UTC） 比较(eq)
   */
  private String earliestShipDateUtcEq;
  /**
   * 发货时限（UTC） 比较(neq)
   */
  private String earliestShipDateUtcNeq;
  /**
   * 发货时限（UTC） 比较(gt)
   */
  private String earliestShipDateUtcGt;
  /**
   * 发货时限（UTC） 比较(gte)
   */
  private String earliestShipDateUtcGte;
  /**
   * 发货时限（UTC） 比较(lt)
   */
  private String earliestShipDateUtcLt;
  /**
   * 发货时限（UTC） 比较(lte)
   */
  private String earliestShipDateUtcLte;
  /**
   * 发货时限（UTC） 比较(contains)
   */
  private String earliestShipDateUtcContains;
  /**
   * 发货时限（UTC） 比较(notcontains)
   */
  private String earliestShipDateUtcNotcontains;
  /**
   * 发货时限（UTC） 比较(startswith)
   */
  private String earliestShipDateUtcStartswith;
  /**
   * 发货时限（UTC） 比较(endswith)
   */
  private String earliestShipDateUtcEndswith;
  /**
   * 发货时限（UTC） 比较(isnull)
   */
  private Boolean earliestShipDateUtcIsnull;
  /**
   * 发货时限（UTC） 比较(isnotnull)
   */
  private Boolean earliestShipDateUtcIsnotnull;

  /**
   * 发货时限（UTC）(精确搜索)
   */
  private List<String> earliestShipDateUtcInList;

  /**
   * 地址1(模糊搜索)
   */
  private String addressLine1;

  /**
   * 地址1 比较(eq)
   */
  private String addressLine1Eq;
  /**
   * 地址1 比较(neq)
   */
  private String addressLine1Neq;
  /**
   * 地址1 比较(gt)
   */
  private String addressLine1Gt;
  /**
   * 地址1 比较(gte)
   */
  private String addressLine1Gte;
  /**
   * 地址1 比较(lt)
   */
  private String addressLine1Lt;
  /**
   * 地址1 比较(lte)
   */
  private String addressLine1Lte;
  /**
   * 地址1 比较(contains)
   */
  private String addressLine1Contains;
  /**
   * 地址1 比较(notcontains)
   */
  private String addressLine1Notcontains;
  /**
   * 地址1 比较(startswith)
   */
  private String addressLine1Startswith;
  /**
   * 地址1 比较(endswith)
   */
  private String addressLine1Endswith;
  /**
   * 地址1 比较(isnull)
   */
  private Boolean addressLine1Isnull;
  /**
   * 地址1 比较(isnotnull)
   */
  private Boolean addressLine1Isnotnull;

  /**
   * 地址1(精确搜索)
   */
  private List<String> addressLine1InList;

  /**
   * 地址2(模糊搜索)
   */
  private String address2;

  /**
   * 地址2 比较(eq)
   */
  private String address2Eq;
  /**
   * 地址2 比较(neq)
   */
  private String address2Neq;
  /**
   * 地址2 比较(gt)
   */
  private String address2Gt;
  /**
   * 地址2 比较(gte)
   */
  private String address2Gte;
  /**
   * 地址2 比较(lt)
   */
  private String address2Lt;
  /**
   * 地址2 比较(lte)
   */
  private String address2Lte;
  /**
   * 地址2 比较(contains)
   */
  private String address2Contains;
  /**
   * 地址2 比较(notcontains)
   */
  private String address2Notcontains;
  /**
   * 地址2 比较(startswith)
   */
  private String address2Startswith;
  /**
   * 地址2 比较(endswith)
   */
  private String address2Endswith;
  /**
   * 地址2 比较(isnull)
   */
  private Boolean address2Isnull;
  /**
   * 地址2 比较(isnotnull)
   */
  private Boolean address2Isnotnull;

  /**
   * 地址2(精确搜索)
   */
  private List<String> address2InList;

  /**
   * 地址3(模糊搜索)
   */
  private String address3;

  /**
   * 地址3 比较(eq)
   */
  private String address3Eq;
  /**
   * 地址3 比较(neq)
   */
  private String address3Neq;
  /**
   * 地址3 比较(gt)
   */
  private String address3Gt;
  /**
   * 地址3 比较(gte)
   */
  private String address3Gte;
  /**
   * 地址3 比较(lt)
   */
  private String address3Lt;
  /**
   * 地址3 比较(lte)
   */
  private String address3Lte;
  /**
   * 地址3 比较(contains)
   */
  private String address3Contains;
  /**
   * 地址3 比较(notcontains)
   */
  private String address3Notcontains;
  /**
   * 地址3 比较(startswith)
   */
  private String address3Startswith;
  /**
   * 地址3 比较(endswith)
   */
  private String address3Endswith;
  /**
   * 地址3 比较(isnull)
   */
  private Boolean address3Isnull;
  /**
   * 地址3 比较(isnotnull)
   */
  private Boolean address3Isnotnull;

  /**
   * 地址3(精确搜索)
   */
  private List<String> address3InList;

  /**
   * 电话(模糊搜索)
   */
  private String phone;

  /**
   * 电话 比较(eq)
   */
  private String phoneEq;
  /**
   * 电话 比较(neq)
   */
  private String phoneNeq;
  /**
   * 电话 比较(gt)
   */
  private String phoneGt;
  /**
   * 电话 比较(gte)
   */
  private String phoneGte;
  /**
   * 电话 比较(lt)
   */
  private String phoneLt;
  /**
   * 电话 比较(lte)
   */
  private String phoneLte;
  /**
   * 电话 比较(contains)
   */
  private String phoneContains;
  /**
   * 电话 比较(notcontains)
   */
  private String phoneNotcontains;
  /**
   * 电话 比较(startswith)
   */
  private String phoneStartswith;
  /**
   * 电话 比较(endswith)
   */
  private String phoneEndswith;
  /**
   * 电话 比较(isnull)
   */
  private Boolean phoneIsnull;
  /**
   * 电话 比较(isnotnull)
   */
  private Boolean phoneIsnotnull;

  /**
   * 电话(精确搜索)
   */
  private List<String> phoneInList;

  /**
   * 用户收货名(模糊搜索)
   */
  private String name;

  /**
   * 用户收货名 比较(eq)
   */
  private String nameEq;
  /**
   * 用户收货名 比较(neq)
   */
  private String nameNeq;
  /**
   * 用户收货名 比较(gt)
   */
  private String nameGt;
  /**
   * 用户收货名 比较(gte)
   */
  private String nameGte;
  /**
   * 用户收货名 比较(lt)
   */
  private String nameLt;
  /**
   * 用户收货名 比较(lte)
   */
  private String nameLte;
  /**
   * 用户收货名 比较(contains)
   */
  private String nameContains;
  /**
   * 用户收货名 比较(notcontains)
   */
  private String nameNotcontains;
  /**
   * 用户收货名 比较(startswith)
   */
  private String nameStartswith;
  /**
   * 用户收货名 比较(endswith)
   */
  private String nameEndswith;
  /**
   * 用户收货名 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 用户收货名 比较(isnotnull)
   */
  private Boolean nameIsnotnull;

  /**
   * 用户收货名(精确搜索)
   */
  private List<String> nameInList;

  /**
   * 是否为B2B订单(模糊搜索)
   */
  private String isBusinessOrder;

  /**
   * 是否为B2B订单 比较(eq)
   */
  private String isBusinessOrderEq;
  /**
   * 是否为B2B订单 比较(neq)
   */
  private String isBusinessOrderNeq;
  /**
   * 是否为B2B订单 比较(gt)
   */
  private String isBusinessOrderGt;
  /**
   * 是否为B2B订单 比较(gte)
   */
  private String isBusinessOrderGte;
  /**
   * 是否为B2B订单 比较(lt)
   */
  private String isBusinessOrderLt;
  /**
   * 是否为B2B订单 比较(lte)
   */
  private String isBusinessOrderLte;
  /**
   * 是否为B2B订单 比较(contains)
   */
  private String isBusinessOrderContains;
  /**
   * 是否为B2B订单 比较(notcontains)
   */
  private String isBusinessOrderNotcontains;
  /**
   * 是否为B2B订单 比较(startswith)
   */
  private String isBusinessOrderStartswith;
  /**
   * 是否为B2B订单 比较(endswith)
   */
  private String isBusinessOrderEndswith;
  /**
   * 是否为B2B订单 比较(isnull)
   */
  private Boolean isBusinessOrderIsnull;
  /**
   * 是否为B2B订单 比较(isnotnull)
   */
  private Boolean isBusinessOrderIsnotnull;

  /**
   * 是否为B2B订单(精确搜索)
   */
  private List<String> isBusinessOrderInList;

  /**
   * 是否含税
   */
  private String taxesIncluded;

  /**
   * 是否含税 比较(eq)
   */
  private String taxesIncludedEq;
  /**
   * 是否含税 比较(neq)
   */
  private String taxesIncludedNeq;
  /**
   * 是否含税 比较(gt)
   */
  private String taxesIncludedGt;
  /**
   * 是否含税 比较(gte)
   */
  private String taxesIncludedGte;
  /**
   * 是否含税 比较(lt)
   */
  private String taxesIncludedLt;
  /**
   * 是否含税 比较(lte)
   */
  private String taxesIncludedLte;
  /**
   * 是否含税 比较(contains)
   */
  private String taxesIncludedContains;
  /**
   * 是否含税 比较(notcontains)
   */
  private String taxesIncludedNotcontains;
  /**
   * 是否含税 比较(startswith)
   */
  private String taxesIncludedStartswith;
  /**
   * 是否含税 比较(endswith)
   */
  private String taxesIncludedEndswith;
  /**
   * 是否含税 比较(isnull)
   */
  private Boolean taxesIncludedIsnull;
  /**
   * 是否含税 比较(isnotnull)
   */
  private Boolean taxesIncludedIsnotnull;

  /**
   * 是否含税(精确搜索)
   */
  private List<String> taxesIncludedInList;

  /**
   * 发货地址(模糊搜索)
   */
  private String shippingAddress;

  /**
   * 发货地址 比较(eq)
   */
  private String shippingAddressEq;
  /**
   * 发货地址 比较(neq)
   */
  private String shippingAddressNeq;
  /**
   * 发货地址 比较(gt)
   */
  private String shippingAddressGt;
  /**
   * 发货地址 比较(gte)
   */
  private String shippingAddressGte;
  /**
   * 发货地址 比较(lt)
   */
  private String shippingAddressLt;
  /**
   * 发货地址 比较(lte)
   */
  private String shippingAddressLte;
  /**
   * 发货地址 比较(contains)
   */
  private String shippingAddressContains;
  /**
   * 发货地址 比较(notcontains)
   */
  private String shippingAddressNotcontains;
  /**
   * 发货地址 比较(startswith)
   */
  private String shippingAddressStartswith;
  /**
   * 发货地址 比较(endswith)
   */
  private String shippingAddressEndswith;
  /**
   * 发货地址 比较(isnull)
   */
  private Boolean shippingAddressIsnull;
  /**
   * 发货地址 比较(isnotnull)
   */
  private Boolean shippingAddressIsnotnull;

  /**
   * 发货地址(精确搜索)
   */
  private List<String> shippingAddressInList;

  /**
   * 配送服务(模糊搜索)
   */
  private String shipServiceLevel;

  /**
   * 配送服务 比较(eq)
   */
  private String shipServiceLevelEq;
  /**
   * 配送服务 比较(neq)
   */
  private String shipServiceLevelNeq;
  /**
   * 配送服务 比较(gt)
   */
  private String shipServiceLevelGt;
  /**
   * 配送服务 比较(gte)
   */
  private String shipServiceLevelGte;
  /**
   * 配送服务 比较(lt)
   */
  private String shipServiceLevelLt;
  /**
   * 配送服务 比较(lte)
   */
  private String shipServiceLevelLte;
  /**
   * 配送服务 比较(contains)
   */
  private String shipServiceLevelContains;
  /**
   * 配送服务 比较(notcontains)
   */
  private String shipServiceLevelNotcontains;
  /**
   * 配送服务 比较(startswith)
   */
  private String shipServiceLevelStartswith;
  /**
   * 配送服务 比较(endswith)
   */
  private String shipServiceLevelEndswith;
  /**
   * 配送服务 比较(isnull)
   */
  private Boolean shipServiceLevelIsnull;
  /**
   * 配送服务 比较(isnotnull)
   */
  private Boolean shipServiceLevelIsnotnull;

  /**
   * 配送服务(精确搜索)
   */
  private List<String> shipServiceLevelInList;

  /**
   * 装运服务级别(模糊搜索)
   */
  private String shipmentServiceLevelCategory;

  /**
   * 装运服务级别 比较(eq)
   */
  private String shipmentServiceLevelCategoryEq;
  /**
   * 装运服务级别 比较(neq)
   */
  private String shipmentServiceLevelCategoryNeq;
  /**
   * 装运服务级别 比较(gt)
   */
  private String shipmentServiceLevelCategoryGt;
  /**
   * 装运服务级别 比较(gte)
   */
  private String shipmentServiceLevelCategoryGte;
  /**
   * 装运服务级别 比较(lt)
   */
  private String shipmentServiceLevelCategoryLt;
  /**
   * 装运服务级别 比较(lte)
   */
  private String shipmentServiceLevelCategoryLte;
  /**
   * 装运服务级别 比较(contains)
   */
  private String shipmentServiceLevelCategoryContains;
  /**
   * 装运服务级别 比较(notcontains)
   */
  private String shipmentServiceLevelCategoryNotcontains;
  /**
   * 装运服务级别 比较(startswith)
   */
  private String shipmentServiceLevelCategoryStartswith;
  /**
   * 装运服务级别 比较(endswith)
   */
  private String shipmentServiceLevelCategoryEndswith;
  /**
   * 装运服务级别 比较(isnull)
   */
  private Boolean shipmentServiceLevelCategoryIsnull;
  /**
   * 装运服务级别 比较(isnotnull)
   */
  private Boolean shipmentServiceLevelCategoryIsnotnull;

  /**
   * 装运服务级别(精确搜索)
   */
  private List<String> shipmentServiceLevelCategoryInList;

  /**
   * 采购订单编号（买家结账时输入）(模糊搜索)
   */
  private String purchaseOrderCode;

  /**
   * 采购订单编号（买家结账时输入） 比较(eq)
   */
  private String purchaseOrderCodeEq;
  /**
   * 采购订单编号（买家结账时输入） 比较(neq)
   */
  private String purchaseOrderCodeNeq;
  /**
   * 采购订单编号（买家结账时输入） 比较(gt)
   */
  private String purchaseOrderCodeGt;
  /**
   * 采购订单编号（买家结账时输入） 比较(gte)
   */
  private String purchaseOrderCodeGte;
  /**
   * 采购订单编号（买家结账时输入） 比较(lt)
   */
  private String purchaseOrderCodeLt;
  /**
   * 采购订单编号（买家结账时输入） 比较(lte)
   */
  private String purchaseOrderCodeLte;
  /**
   * 采购订单编号（买家结账时输入） 比较(contains)
   */
  private String purchaseOrderCodeContains;
  /**
   * 采购订单编号（买家结账时输入） 比较(notcontains)
   */
  private String purchaseOrderCodeNotcontains;
  /**
   * 采购订单编号（买家结账时输入） 比较(startswith)
   */
  private String purchaseOrderCodeStartswith;
  /**
   * 采购订单编号（买家结账时输入） 比较(endswith)
   */
  private String purchaseOrderCodeEndswith;
  /**
   * 采购订单编号（买家结账时输入） 比较(isnull)
   */
  private Boolean purchaseOrderCodeIsnull;
  /**
   * 采购订单编号（买家结账时输入） 比较(isnotnull)
   */
  private Boolean purchaseOrderCodeIsnotnull;

  /**
   * 采购订单编号（买家结账时输入）(精确搜索)
   */
  private List<String> purchaseOrderCodeInList;

  /**
   * 采购订单id
   */
  private Long purchaseOrderId;

  /**
   * 最小采购订单id
   */
  private Long purchaseOrderIdMin;

  /**
   * 最大采购订单id
   */
  private Long purchaseOrderIdMax;

  /**
   * 采购订单id 比较(eq)
   */
  private Long purchaseOrderIdEq;
  /**
   * 采购订单id 比较(neq)
   */
  private Long purchaseOrderIdNeq;
  /**
   * 采购订单id 比较(gt)
   */
  private Long purchaseOrderIdGt;
  /**
   * 采购订单id 比较(gte)
   */
  private Long purchaseOrderIdGte;
  /**
   * 采购订单id 比较(lt)
   */
  private Long purchaseOrderIdLt;
  /**
   * 采购订单id 比较(lte)
   */
  private Long purchaseOrderIdLte;
  /**
   * 采购订单id 比较(contains)
   */
  private Long purchaseOrderIdContains;
  /**
   * 采购订单id 比较(notcontains)
   */
  private Long purchaseOrderIdNotcontains;
  /**
   * 采购订单id 比较(startswith)
   */
  private Long purchaseOrderIdStartswith;
  /**
   * 采购订单id 比较(endswith)
   */
  private Long purchaseOrderIdEndswith;
  /**
   * 采购订单id 比较(isnull)
   */
  private Boolean purchaseOrderIdIsnull;
  /**
   * 采购订单id 比较(isnotnull)
   */
  private Boolean purchaseOrderIdIsnotnull;

  /**
   * 付款方式 COD (Cash on delivery)(模糊搜索)
   */
  private String paymentMethod;

  /**
   * 付款方式 COD (Cash on delivery) 比较(eq)
   */
  private String paymentMethodEq;
  /**
   * 付款方式 COD (Cash on delivery) 比较(neq)
   */
  private String paymentMethodNeq;
  /**
   * 付款方式 COD (Cash on delivery) 比较(gt)
   */
  private String paymentMethodGt;
  /**
   * 付款方式 COD (Cash on delivery) 比较(gte)
   */
  private String paymentMethodGte;
  /**
   * 付款方式 COD (Cash on delivery) 比较(lt)
   */
  private String paymentMethodLt;
  /**
   * 付款方式 COD (Cash on delivery) 比较(lte)
   */
  private String paymentMethodLte;
  /**
   * 付款方式 COD (Cash on delivery) 比较(contains)
   */
  private String paymentMethodContains;
  /**
   * 付款方式 COD (Cash on delivery) 比较(notcontains)
   */
  private String paymentMethodNotcontains;
  /**
   * 付款方式 COD (Cash on delivery) 比较(startswith)
   */
  private String paymentMethodStartswith;
  /**
   * 付款方式 COD (Cash on delivery) 比较(endswith)
   */
  private String paymentMethodEndswith;
  /**
   * 付款方式 COD (Cash on delivery) 比较(isnull)
   */
  private Boolean paymentMethodIsnull;
  /**
   * 付款方式 COD (Cash on delivery) 比较(isnotnull)
   */
  private Boolean paymentMethodIsnotnull;

  /**
   * 付款方式 COD (Cash on delivery)(精确搜索)
   */
  private List<String> paymentMethodInList;

  /**
   * 亚马逊结账（CBA）的自定义发货标签(模糊搜索)
   */
  private String cbaDisplayAbleShippingLabel;

  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(eq)
   */
  private String cbaDisplayAbleShippingLabelEq;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(neq)
   */
  private String cbaDisplayAbleShippingLabelNeq;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(gt)
   */
  private String cbaDisplayAbleShippingLabelGt;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(gte)
   */
  private String cbaDisplayAbleShippingLabelGte;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(lt)
   */
  private String cbaDisplayAbleShippingLabelLt;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(lte)
   */
  private String cbaDisplayAbleShippingLabelLte;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(contains)
   */
  private String cbaDisplayAbleShippingLabelContains;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(notcontains)
   */
  private String cbaDisplayAbleShippingLabelNotcontains;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(startswith)
   */
  private String cbaDisplayAbleShippingLabelStartswith;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(endswith)
   */
  private String cbaDisplayAbleShippingLabelEndswith;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(isnull)
   */
  private Boolean cbaDisplayAbleShippingLabelIsnull;
  /**
   * 亚马逊结账（CBA）的自定义发货标签 比较(isnotnull)
   */
  private Boolean cbaDisplayAbleShippingLabelIsnotnull;

  /**
   * 亚马逊结账（CBA）的自定义发货标签(精确搜索)
   */
  private List<String> cbaDisplayAbleShippingLabelInList;

  /**
   * 订单类型(模糊搜索)
   */
  private String orderType;

  /**
   * 订单类型 比较(eq)
   */
  private String orderTypeEq;
  /**
   * 订单类型 比较(neq)
   */
  private String orderTypeNeq;
  /**
   * 订单类型 比较(gt)
   */
  private String orderTypeGt;
  /**
   * 订单类型 比较(gte)
   */
  private String orderTypeGte;
  /**
   * 订单类型 比较(lt)
   */
  private String orderTypeLt;
  /**
   * 订单类型 比较(lte)
   */
  private String orderTypeLte;
  /**
   * 订单类型 比较(contains)
   */
  private String orderTypeContains;
  /**
   * 订单类型 比较(notcontains)
   */
  private String orderTypeNotcontains;
  /**
   * 订单类型 比较(startswith)
   */
  private String orderTypeStartswith;
  /**
   * 订单类型 比较(endswith)
   */
  private String orderTypeEndswith;
  /**
   * 订单类型 比较(isnull)
   */
  private Boolean orderTypeIsnull;
  /**
   * 订单类型 比较(isnotnull)
   */
  private Boolean orderTypeIsnotnull;

  /**
   * 订单类型(精确搜索)
   */
  private List<String> orderTypeInList;

  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间）(模糊搜索)
   */
  private String latestShipDate;

  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(eq)
   */
  private String latestShipDateEq;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(neq)
   */
  private String latestShipDateNeq;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(gt)
   */
  private String latestShipDateGt;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(gte)
   */
  private String latestShipDateGte;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(lt)
   */
  private String latestShipDateLt;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(lte)
   */
  private String latestShipDateLte;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(contains)
   */
  private String latestShipDateContains;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(notcontains)
   */
  private String latestShipDateNotcontains;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(startswith)
   */
  private String latestShipDateStartswith;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(endswith)
   */
  private String latestShipDateEndswith;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(isnull)
   */
  private Boolean latestShipDateIsnull;
  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间） 比较(isnotnull)
   */
  private Boolean latestShipDateIsnotnull;

  /**
   * 最晚发货时间（承诺配送订单的最晚发货时间）(精确搜索)
   */
  private List<String> latestShipDateInList;

  /**
   * 最早送达时间（承诺送达订单的最早送达时间）(模糊搜索)
   */
  private String earliestDeliveryDate;

  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(eq)
   */
  private String earliestDeliveryDateEq;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(neq)
   */
  private String earliestDeliveryDateNeq;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(gt)
   */
  private String earliestDeliveryDateGt;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(gte)
   */
  private String earliestDeliveryDateGte;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(lt)
   */
  private String earliestDeliveryDateLt;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(lte)
   */
  private String earliestDeliveryDateLte;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(contains)
   */
  private String earliestDeliveryDateContains;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(notcontains)
   */
  private String earliestDeliveryDateNotcontains;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(startswith)
   */
  private String earliestDeliveryDateStartswith;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(endswith)
   */
  private String earliestDeliveryDateEndswith;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(isnull)
   */
  private Boolean earliestDeliveryDateIsnull;
  /**
   * 最早送达时间（承诺送达订单的最早送达时间） 比较(isnotnull)
   */
  private Boolean earliestDeliveryDateIsnotnull;

  /**
   * 最早送达时间（承诺送达订单的最早送达时间）(精确搜索)
   */
  private List<String> earliestDeliveryDateInList;

  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间）(模糊搜索)
   */
  private String latestDeliveryDate;

  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(eq)
   */
  private String latestDeliveryDateEq;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(neq)
   */
  private String latestDeliveryDateNeq;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(gt)
   */
  private String latestDeliveryDateGt;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(gte)
   */
  private String latestDeliveryDateGte;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(lt)
   */
  private String latestDeliveryDateLt;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(lte)
   */
  private String latestDeliveryDateLte;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(contains)
   */
  private String latestDeliveryDateContains;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(notcontains)
   */
  private String latestDeliveryDateNotcontains;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(startswith)
   */
  private String latestDeliveryDateStartswith;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(endswith)
   */
  private String latestDeliveryDateEndswith;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(isnull)
   */
  private Boolean latestDeliveryDateIsnull;
  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间） 比较(isnotnull)
   */
  private Boolean latestDeliveryDateIsnotnull;

  /**
   * 最晚送达时间（承诺送达订单的最晚送达时间）(精确搜索)
   */
  private List<String> latestDeliveryDateInList;

  /**
   * 已发货的商品数(模糊搜索)
   */
  private String numberOfItemsShipped;

  /**
   * 已发货的商品数 比较(eq)
   */
  private String numberOfItemsShippedEq;
  /**
   * 已发货的商品数 比较(neq)
   */
  private String numberOfItemsShippedNeq;
  /**
   * 已发货的商品数 比较(gt)
   */
  private String numberOfItemsShippedGt;
  /**
   * 已发货的商品数 比较(gte)
   */
  private String numberOfItemsShippedGte;
  /**
   * 已发货的商品数 比较(lt)
   */
  private String numberOfItemsShippedLt;
  /**
   * 已发货的商品数 比较(lte)
   */
  private String numberOfItemsShippedLte;
  /**
   * 已发货的商品数 比较(contains)
   */
  private String numberOfItemsShippedContains;
  /**
   * 已发货的商品数 比较(notcontains)
   */
  private String numberOfItemsShippedNotcontains;
  /**
   * 已发货的商品数 比较(startswith)
   */
  private String numberOfItemsShippedStartswith;
  /**
   * 已发货的商品数 比较(endswith)
   */
  private String numberOfItemsShippedEndswith;
  /**
   * 已发货的商品数 比较(isnull)
   */
  private Boolean numberOfItemsShippedIsnull;
  /**
   * 已发货的商品数 比较(isnotnull)
   */
  private Boolean numberOfItemsShippedIsnotnull;

  /**
   * 已发货的商品数(精确搜索)
   */
  private List<String> numberOfItemsShippedInList;

  /**
   * 未发货的商品数(模糊搜索)
   */
  private String numberOfItemsUnShipped;

  /**
   * 未发货的商品数 比较(eq)
   */
  private String numberOfItemsUnShippedEq;
  /**
   * 未发货的商品数 比较(neq)
   */
  private String numberOfItemsUnShippedNeq;
  /**
   * 未发货的商品数 比较(gt)
   */
  private String numberOfItemsUnShippedGt;
  /**
   * 未发货的商品数 比较(gte)
   */
  private String numberOfItemsUnShippedGte;
  /**
   * 未发货的商品数 比较(lt)
   */
  private String numberOfItemsUnShippedLt;
  /**
   * 未发货的商品数 比较(lte)
   */
  private String numberOfItemsUnShippedLte;
  /**
   * 未发货的商品数 比较(contains)
   */
  private String numberOfItemsUnShippedContains;
  /**
   * 未发货的商品数 比较(notcontains)
   */
  private String numberOfItemsUnShippedNotcontains;
  /**
   * 未发货的商品数 比较(startswith)
   */
  private String numberOfItemsUnShippedStartswith;
  /**
   * 未发货的商品数 比较(endswith)
   */
  private String numberOfItemsUnShippedEndswith;
  /**
   * 未发货的商品数 比较(isnull)
   */
  private Boolean numberOfItemsUnShippedIsnull;
  /**
   * 未发货的商品数 比较(isnotnull)
   */
  private Boolean numberOfItemsUnShippedIsnotnull;

  /**
   * 未发货的商品数(精确搜索)
   */
  private List<String> numberOfItemsUnShippedInList;

  /**
   * 销售渠道(模糊搜索)
   */
  private String salesChannel;

  /**
   * 销售渠道 比较(eq)
   */
  private String salesChannelEq;
  /**
   * 销售渠道 比较(neq)
   */
  private String salesChannelNeq;
  /**
   * 销售渠道 比较(gt)
   */
  private String salesChannelGt;
  /**
   * 销售渠道 比较(gte)
   */
  private String salesChannelGte;
  /**
   * 销售渠道 比较(lt)
   */
  private String salesChannelLt;
  /**
   * 销售渠道 比较(lte)
   */
  private String salesChannelLte;
  /**
   * 销售渠道 比较(contains)
   */
  private String salesChannelContains;
  /**
   * 销售渠道 比较(notcontains)
   */
  private String salesChannelNotcontains;
  /**
   * 销售渠道 比较(startswith)
   */
  private String salesChannelStartswith;
  /**
   * 销售渠道 比较(endswith)
   */
  private String salesChannelEndswith;
  /**
   * 销售渠道 比较(isnull)
   */
  private Boolean salesChannelIsnull;
  /**
   * 销售渠道 比较(isnotnull)
   */
  private Boolean salesChannelIsnotnull;

  /**
   * 销售渠道(精确搜索)
   */
  private List<String> salesChannelInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 是否推广
   */
  private String isPromotion;

  /**
   * 是否推广 比较(eq)
   */
  private String isPromotionEq;
  /**
   * 是否推广 比较(neq)
   */
  private String isPromotionNeq;
  /**
   * 是否推广 比较(gt)
   */
  private String isPromotionGt;
  /**
   * 是否推广 比较(gte)
   */
  private String isPromotionGte;
  /**
   * 是否推广 比较(lt)
   */
  private String isPromotionLt;
  /**
   * 是否推广 比较(lte)
   */
  private String isPromotionLte;
  /**
   * 是否推广 比较(contains)
   */
  private String isPromotionContains;
  /**
   * 是否推广 比较(notcontains)
   */
  private String isPromotionNotcontains;
  /**
   * 是否推广 比较(startswith)
   */
  private String isPromotionStartswith;
  /**
   * 是否推广 比较(endswith)
   */
  private String isPromotionEndswith;
  /**
   * 是否推广 比较(isnull)
   */
  private Boolean isPromotionIsnull;
  /**
   * 是否推广 比较(isnotnull)
   */
  private Boolean isPromotionIsnotnull;

  /**
   * 是否推广(精确搜索)
   */
  private List<String> isPromotionInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
